import type { Question } from '@/types/exam';

/**
 * Java核心API题目（初级10道 + 中级10道 + 高级10道）
 */
export const coreQuestions: Question[] = [
	// ========== 初级题目（10道） ==========
	{
		id: 3001,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，String类是不可变的。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'String类是不可变的，一旦创建就不能修改。每次字符串操作都会创建新的String对象。'
	},
	{
		id: 3002,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个类用于表示日期？',
		options: [
			{ key: 'A', text: 'Date' },
			{ key: 'B', text: 'Time' },
			{ key: 'C', text: 'Calendar' },
			{ key: 'D', text: 'A和C都可以' }
		],
		answer: ['D'],
		explanation: 'Java中Date和Calendar都可以表示日期。Date表示时间点，Calendar用于日期操作。Java 8+推荐使用LocalDate等。'
	},
	{
		id: 3003,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个集合类是有序的？',
		options: [
			{ key: 'A', text: 'HashSet' },
			{ key: 'B', text: 'LinkedHashSet' },
			{ key: 'C', text: 'HashMap' },
			{ key: 'D', text: 'TreeSet' }
		],
		answer: ['B'],
		explanation: 'LinkedHashSet是有序的，保持插入顺序。TreeSet是有序的，按自然顺序或比较器排序。HashSet和HashMap是无序的。'
	},
	{
		id: 3004,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个方法用于比较两个字符串的内容？',
		options: [
			{ key: 'A', text: '==' },
			{ key: 'B', text: 'equals()' },
			{ key: 'C', text: 'compareTo()' },
			{ key: 'D', text: 'B和C都可以' }
		],
		answer: ['B'],
		explanation: 'equals()方法用于比较两个字符串的内容是否相等。==比较的是引用地址。compareTo()用于比较字符串的大小顺序。'
	},
	{
		id: 3005,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'ArrayList和LinkedList都是List接口的实现类。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'ArrayList和LinkedList都是List接口的实现类。ArrayList基于数组实现，LinkedList基于双向链表实现。'
	},
	{
		id: 3006,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个集合类不允许重复元素？',
		options: [
			{ key: 'A', text: 'List' },
			{ key: 'B', text: 'Set' },
			{ key: 'C', text: 'Map' },
			{ key: 'D', text: 'Queue' }
		],
		answer: ['B'],
		explanation: 'Set集合不允许重复元素。List允许重复元素，Map存储键值对，Queue是队列。'
	},
	{
		id: 3007,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个用于格式化输出？',
		options: [
			{ key: 'A', text: 'System.out.print()' },
			{ key: 'B', text: 'System.out.println()' },
			{ key: 'C', text: 'String.format()' },
			{ key: 'D', text: '以上都可以' }
		],
		answer: ['C'],
		explanation: 'String.format()用于格式化输出，类似于C语言的printf。System.out.print()和println()用于简单输出。'
	},
	{
		id: 3008,
		techId: 'java',
		type: 'judge',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'HashMap允许null键和null值。',
		options: [
			{ key: 'A', text: '正确' },
			{ key: 'B', text: '错误' }
		],
		answer: ['A'],
		explanation: 'HashMap允许一个null键和多个null值。Hashtable不允许null键和null值。TreeMap不允许null键，但允许null值。'
	},
	{
		id: 3009,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个类用于生成随机数？',
		options: [
			{ key: 'A', text: 'Random' },
			{ key: 'B', text: 'Math.random()' },
			{ key: 'C', text: 'A和B都可以' },
			{ key: 'D', text: '只能使用Random类' }
		],
		answer: ['C'],
		explanation: 'Random类和Math.random()都可以生成随机数。Random类功能更强大，可以生成不同类型的随机数。Math.random()返回0.0到1.0之间的double值。'
	},
	{
		id: 3010,
		techId: 'java',
		type: 'single',
		difficulty: 'easy',
		category: 'Java核心API',
		question: 'Java中，以下哪个方法用于将字符串转换为整数？',
		options: [
			{ key: 'A', text: 'Integer.parseInt()' },
			{ key: 'B', text: 'Integer.valueOf()' },
			{ key: 'C', text: 'String.toInteger()' },
			{ key: 'D', text: 'A和B都可以' }
		],
		answer: ['D'],
		explanation: 'Integer.parseInt()返回int基本类型，Integer.valueOf()返回Integer对象。两者都可以将字符串转换为整数。'
	},

	// ========== 中级题目（10道） ==========
	{
		id: 3011,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'String、StringBuilder和StringBuffer的区别，以下说法正确的是？',
		options: [
			{ key: 'A', text: 'String是可变的，StringBuilder和StringBuffer是不可变的' },
			{ key: 'B', text: 'StringBuilder是线程安全的，StringBuffer不是' },
			{ key: 'C', text: 'String是不可变的，StringBuffer是线程安全的' },
			{ key: 'D', text: '三者性能相同' }
		],
		answer: ['C'],
		explanation: 'String是不可变的；StringBuffer是线程安全的（方法加了synchronized）；StringBuilder是非线程安全的，性能更高。'
	},
	{
		id: 3012,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于ArrayList和LinkedList的说法是正确的？',
		options: [
			{ key: 'A', text: 'ArrayList适合随机访问，LinkedList适合插入删除' },
			{ key: 'B', text: 'ArrayList适合插入删除，LinkedList适合随机访问' },
			{ key: 'C', text: '两者性能相同' },
			{ key: 'D', text: 'ArrayList不能存储null值' }
		],
		answer: ['A'],
		explanation: 'ArrayList基于数组，适合随机访问（O(1)），但插入删除需要移动元素（O(n)）。LinkedList基于链表，适合插入删除（O(1)），但随机访问需要遍历（O(n)）。'
	},
	{
		id: 3013,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于HashMap的说法是正确的？',
		options: [
			{ key: 'A', text: 'HashMap是有序的' },
			{ key: 'B', text: 'HashMap默认初始容量是16，加载因子是0.75' },
			{ key: 'C', text: 'HashMap不能存储null值' },
			{ key: 'D', text: 'HashMap是线程安全的' }
		],
		answer: ['B'],
		explanation: 'HashMap默认初始容量是16，加载因子是0.75。当元素数量超过容量*加载因子时，会进行扩容。HashMap是无序的，允许null值，不是线程安全的。'
	},
	{
		id: 3014,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于Collections工具类的说法是正确的？',
		options: [
			{ key: 'A', text: 'Collections.sort()只能对List排序' },
			{ key: 'B', text: 'Collections.reverse()可以反转List' },
			{ key: 'C', text: 'Collections只能操作List' },
			{ key: 'D', text: 'Collections不能创建线程安全的集合' }
		],
		answer: ['B'],
		explanation: 'Collections工具类提供多种静态方法：sort()对List排序、reverse()反转List、synchronizedList()创建线程安全的List等。'
	},
	{
		id: 3015,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于正则表达式的说法是正确的？',
		options: [
			{ key: 'A', text: 'Pattern类用于编译正则表达式' },
			{ key: 'B', text: 'Matcher类用于匹配字符串' },
			{ key: 'C', text: 'String.matches()也可以使用正则表达式' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: 'Pattern类用于编译正则表达式，Matcher类用于匹配字符串，String.matches()方法也可以使用正则表达式进行匹配。'
	},
	{
		id: 3016,
		techId: 'java',
		type: 'multiple',
		difficulty: 'medium',
		category: 'Java核心API',
		question: '以下哪些是Java的集合框架接口？',
		options: [
			{ key: 'A', text: 'Collection' },
			{ key: 'B', text: 'List' },
			{ key: 'C', text: 'Set' },
			{ key: 'D', text: 'Map' }
		],
		answer: ['A', 'B', 'C', 'D'],
		explanation: 'Java集合框架包括：Collection接口（List、Set的父接口）、List接口、Set接口、Map接口（独立于Collection）。'
	},
	{
		id: 3017,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于Iterator的说法是正确的？',
		options: [
			{ key: 'A', text: 'Iterator只能用于List' },
			{ key: 'B', text: 'Iterator可以用于所有Collection' },
			{ key: 'C', text: 'Iterator不能删除元素' },
			{ key: 'D', text: 'Iterator只能正向遍历' }
		],
		answer: ['B'],
		explanation: 'Iterator可以用于所有Collection（List、Set等），提供统一遍历方式。Iterator可以删除元素（remove()），但只能在调用next()后调用。'
	},
	{
		id: 3018,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于Comparable和Comparator的说法是正确的？',
		options: [
			{ key: 'A', text: 'Comparable是接口，Comparator是类' },
			{ key: 'B', text: 'Comparable定义在类内部，Comparator定义在类外部' },
			{ key: 'C', text: '两者功能相同' },
			{ key: 'D', text: '只能使用Comparable' }
		],
		answer: ['B'],
		explanation: 'Comparable接口定义在类内部（实现compareTo()），Comparator是外部比较器（实现compare()）。两者都用于对象比较和排序。'
	},
	{
		id: 3019,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于String intern()方法的说法是正确的？',
		options: [
			{ key: 'A', text: 'intern()返回字符串对象的引用' },
			{ key: 'B', text: 'intern()从常量池中获取字符串，如果不存在则添加' },
			{ key: 'C', text: 'intern()创建新的字符串对象' },
			{ key: 'D', text: 'intern()不能用于字符串比较' }
		],
		answer: ['B'],
		explanation: 'intern()方法从字符串常量池中获取字符串，如果池中不存在则添加。可以用于字符串比较优化，但要注意内存消耗。'
	},
	{
		id: 3020,
		techId: 'java',
		type: 'single',
		difficulty: 'medium',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于Arrays工具类的说法是正确的？',
		options: [
			{ key: 'A', text: 'Arrays.sort()只能对基本类型数组排序' },
			{ key: 'B', text: 'Arrays.asList()返回的List可以修改大小' },
			{ key: 'C', text: 'Arrays提供排序、搜索、复制等操作' },
			{ key: 'D', text: 'Arrays不能操作对象数组' }
		],
		answer: ['C'],
		explanation: 'Arrays工具类提供多种静态方法：sort()（基本类型和对象数组）、binarySearch()（二分查找）、copyOf()（复制）、asList()（返回固定大小的List）等。'
	},

	// ========== 高级题目（10道） ==========
	{
		id: 3021,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java核心API',
		question: '以下哪些集合是线程安全的？',
		options: [
			{ key: 'A', text: 'Vector' },
			{ key: 'B', text: 'ArrayList' },
			{ key: 'C', text: 'Hashtable' },
			{ key: 'D', text: 'HashMap' }
		],
		answer: ['A', 'C'],
		explanation: 'Vector和Hashtable是线程安全的（方法加了synchronized），但性能较低。ArrayList和HashMap不是线程安全的。Java 5+推荐使用ConcurrentHashMap等并发集合。'
	},
	{
		id: 3022,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于HashMap扩容的说法是正确的？',
		options: [
			{ key: 'A', text: 'HashMap每次扩容容量翻倍' },
			{ key: 'B', text: 'HashMap扩容后需要重新计算所有元素的hash值' },
			{ key: 'C', text: 'HashMap扩容后需要重新分配元素位置' },
			{ key: 'D', text: 'HashMap不会扩容' }
		],
		answer: ['C'],
		explanation: 'HashMap扩容时容量翻倍（如16->32），需要重新计算每个元素的索引位置（因为索引计算依赖容量）。这是HashMap性能开销较大的操作。'
	},
	{
		id: 3023,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于TreeMap的说法是错误的？',
		options: [
			{ key: 'A', text: 'TreeMap基于红黑树实现' },
			{ key: 'B', text: 'TreeMap是有序的，按key排序' },
			{ key: 'C', text: 'TreeMap允许null键' },
			{ key: 'D', text: 'TreeMap的key必须实现Comparable或提供Comparator' }
		],
		answer: ['C'],
		explanation: 'TreeMap基于红黑树实现，是有序的（按key排序）。TreeMap不允许null键，但允许null值。TreeMap的key必须实现Comparable或提供Comparator。'
	},
	{
		id: 3024,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于WeakHashMap的说法是正确的？',
		options: [
			{ key: 'A', text: 'WeakHashMap是强引用' },
			{ key: 'B', text: 'WeakHashMap的key是弱引用，可以被垃圾回收' },
			{ key: 'C', text: 'WeakHashMap性能比HashMap好' },
			{ key: 'D', text: 'WeakHashMap不允许null键' }
		],
		answer: ['B'],
		explanation: 'WeakHashMap的key是弱引用，当key不再被其他对象引用时，可以被垃圾回收。适合用于缓存等场景。WeakHashMap允许null键和null值。'
	},
	{
		id: 3025,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于ConcurrentHashMap的说法是正确的？',
		options: [
			{ key: 'A', text: 'ConcurrentHashMap使用synchronized锁整个表' },
			{ key: 'B', text: 'ConcurrentHashMap使用分段锁（Java 7）或CAS+volatile（Java 8+）' },
			{ key: 'C', text: 'ConcurrentHashMap性能不如Hashtable' },
			{ key: 'D', text: 'ConcurrentHashMap不允许null值' }
		],
		answer: ['B'],
		explanation: 'ConcurrentHashMap使用分段锁（Java 7）或CAS+volatile（Java 8+），性能优于Hashtable。Java 8+不允许null键和null值。'
	},
	{
		id: 3026,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于StringBuilder初始容量的说法是正确的？',
		options: [
			{ key: 'A', text: 'StringBuilder默认初始容量是16' },
			{ key: 'B', text: 'StringBuilder每次扩容容量翻倍' },
			{ key: 'C', text: 'StringBuilder可以指定初始容量' },
			{ key: 'D', text: '以上都对' }
		],
		answer: ['D'],
		explanation: 'StringBuilder默认初始容量是16，可以通过构造函数指定初始容量。当容量不足时，会扩容（通常是原容量的2倍+2）。合理设置初始容量可以提高性能。'
	},
	{
		id: 3027,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于Collections.unmodifiableList()的说法是正确的？',
		options: [
			{ key: 'A', text: '返回的List是完全独立的副本' },
			{ key: 'B', text: '返回的List是原List的视图，不可修改但可以读取' },
			{ key: 'C', text: '返回的List可以修改' },
			{ key: 'D', text: '返回的List不能读取' }
		],
		answer: ['B'],
		explanation: 'Collections.unmodifiableList()返回原List的不可修改视图，可以读取但不能修改。如果原List被修改，视图也会反映变化。'
	},
	{
		id: 3028,
		techId: 'java',
		type: 'multiple',
		difficulty: 'hard',
		category: 'Java核心API',
		question: '以下哪些是Java集合框架中的并发集合（Java 5+）？',
		options: [
			{ key: 'A', text: 'ConcurrentHashMap' },
			{ key: 'B', text: 'CopyOnWriteArrayList' },
			{ key: 'C', text: 'BlockingQueue' },
			{ key: 'D', text: 'Vector' }
		],
		answer: ['A', 'B', 'C'],
		explanation: 'Java 5+引入的并发集合包括：ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet、BlockingQueue等。Vector是旧的线程安全集合，性能较低。'
	},
	{
		id: 3029,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于LinkedHashMap的说法是正确的？',
		options: [
			{ key: 'A', text: 'LinkedHashMap是无序的' },
			{ key: 'B', text: 'LinkedHashMap可以保持插入顺序或访问顺序' },
			{ key: 'C', text: 'LinkedHashMap性能比HashMap好' },
			{ key: 'D', text: 'LinkedHashMap不能存储null值' }
		],
		answer: ['B'],
		explanation: 'LinkedHashMap继承自HashMap，可以保持插入顺序（默认）或访问顺序（通过accessOrder参数）。适合用于LRU缓存等场景。性能略低于HashMap。'
	},
	{
		id: 3030,
		techId: 'java',
		type: 'single',
		difficulty: 'hard',
		category: 'Java核心API',
		question: 'Java中，以下哪个关于String常量池的说法是错误的？',
		options: [
			{ key: 'A', text: '字符串字面量会自动放入常量池' },
			{ key: 'B', text: '使用new String()创建的对象不会放入常量池' },
			{ key: 'C', text: '常量池在方法区（Java 8+在堆内存的元空间）' },
			{ key: 'D', text: '常量池中的字符串可以被垃圾回收' }
		],
		answer: ['D'],
		explanation: '字符串常量池中的字符串通常不会被垃圾回收，因为它们被类信息引用。字符串字面量自动放入常量池，new String()创建的对象需要使用intern()方法才能放入常量池。'
	}
];

